import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

import seaborn as sns

%matplotlib inline

import warnings

warnings.filterwarnings('ignore')

from sklearn.preprocessing import RobustScaler

from sklearn.decomposition import PCA

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import LabelEncoder

from sklearn.metrics import precision_recall_fscore_support, mean_absolute_error

from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

from sklearn.svm import SVC

from sklearn.model_selection import GridSearchCV

data = pd.read_csv('Part3 - vehicle.csv')

data.head()

df = data.copy(deep = True)

rows, column = df.shape

print('The dataset contains', rows, 'rows and', column, 'columns.')

df.info()

print('Duplicated rows: ', df[df.duplicated()].shape[0]) #no duplicate rows

df.isnull().sum()

for cols in df.columns:

    if(cols != 'class'):

        df[cols] = df[cols].fillna(df[cols].median())  

​

df.describe().T

plt.figure(figsize=(25, 20))

col = 1

for i in df.drop(columns = 'class').columns:

    plt.subplot(6, 3, col)

    sns.distplot(df[i], color = 'b', rug =True)

    col += 1

print(df['class'].value_counts())

plt.title('Count of Vehicle Class column')

sns.countplot(x = 'class', data = df)

plt.figure(figsize=(25, 20))

col = 1

for i in df.drop(columns = 'class').columns:

    plt.subplot(6, 3, col)

    sns.boxplot(df[i])

    col +=1

plt.figure(figsize = (18, 5))

plt.subplot(1, 4, 1)

df['scaled_radius_of_gyration.1'].plot(x ='scaled_radius_of_gyration.1', kind = 'box')

plt.title('Boxplot of Scaled Radius of Gyration 1 Column')

​

plt.subplot(1, 4, 2)

df['pr.axis_aspect_ratio'].plot(x = 'pr.axis_aspect_ratio', kind = 'box')

plt.title('Boxplot of pr.axis_aspect_ratio Column')

​

plt.subplot(1, 4, 3)

df.radius_ratio.plot(x = 'radius_ratio', kind = 'box')

plt.title('Boxplot of Radius Ratio Column')

​

plt.subplot(1, 4, 4)

df.skewness_about.plot(x = 'skewness_about', kind = 'box')

plt.title('Boxplot of Skewness About Column')

plt.figure(figsize = (15, 5))

plt.subplot(1, 3, 1)

df.scaled_variance.plot(x = 'scaled_variance', kind = 'box')

plt.title('Boxplot of Scaled Variance Column')

plt.subplot(1, 3, 2)

df['scaled_variance.1'].plot(x = 'scaled_variance.1', kind = 'box')

plt.title('Boxplot of Scaled Variance 1 Column')

plt.subplot(1, 3, 3)

df['skewness_about.1'].plot(x = 'skewness_about.1 ', kind = 'box')

plt.title('Boxplot of Skewness About 1 Column')

​

for col_name in df.drop(columns = 'class').columns:

    q1 = df[col_name].quantile(0.25)

    q3 = df[col_name].quantile(0.75)

    iqr = q3 - q1

    low = q1 - 1.5 * iqr

    high = q3 + 1.5 * iqr

    df.loc[(df[col_name] < low) | (df[col_name] > high), col_name] = df[col_name].median()

plt.figure(figsize=(25, 20))

col = 1

for i in df.drop(columns = 'class').columns:

    plt.subplot(6, 3, col)

    sns.boxplot(df[i])

    col +=1

sns.pairplot(df, diag_kind = 'kde', hue ='class')

correlation = df.corr()

correlation

plt.figure(figsize = (20, 10))

plt.xticks(fontsize = 15)

plt.yticks(fontsize = 15)

plt.title('Correlation HeatMap', fontsize= 15)

sns.heatmap(correlation, annot = True, cmap = 'viridis')

X = df.loc[:, df.columns != 'class']

y = df['class'].astype('category').cat.codes

plt.figure(figsize = (20, 10))

sns.barplot(x = X.columns, y = X.corrwith(y))

plt.title('Correlation with Class column',fontsize = 20)

X_col = X.columns

scaler = RobustScaler()

X_std = pd.DataFrame(scaler.fit_transform(X))

X_std.columns = X_col #the column names are passed to the standardized dataframe

X_std.head()

pca = PCA()

X_pca_ = pca.fit_transform(X_std)

plt.figure(figsize = (12, 8))

plt.plot((np.cumsum(pca.explained_variance_ratio_) * 100), marker = 'X')

plt.xlim(0, 18)

plt.xlabel('Number of Components')

plt.ylabel('Percentage of Cumulative Explained Variance')

plt.figure(figsize = (12, 8))

plt.step(list(range(18)), (np.cumsum(pca.explained_variance_ratio_) * 100), where ='mid')

plt.xlim(0, 18)

plt.xlabel('Number of Components')

plt.ylabel('Percentage of Cumulative Explained Variance')

plt.title('Vehicle Dataset Explained Variance')

print('Eigen Values: \n')

pca.explained_variance_

print('Eigen Vectors: \n')

pca.components_

print('The percentage of variation explained by each Eigen Vector: \n')

pca.explained_variance_ratio_

## PCA visualization how information is captured across components

percent_variance = np.round(pca.explained_variance_ratio_* 100, decimals = 2)

plt.figure(figsize = (12, 8))

plt.bar(x = list(range(18)), height = percent_variance)

plt.xlim(0, 18)

plt.ylabel('Cumulative Explained Variance')

plt.xlabel('Principal Components')

plt.figure(figsize = (12, 8))

plt.step(range(18), np.cumsum(pca.explained_variance_ratio_))

plt.bar(range(18), pca.explained_variance_ratio_)

plt.xlim(0, 18)

plt.ylabel('Explained Variance')

plt.xlabel('Principal Components')

plt.figure(figsize = (12, 8))

plt.plot(range(18), np.cumsum(pca.explained_variance_ratio_), marker = 'X')

plt.plot(range(18), pca.explained_variance_ratio_, marker = 'D')

plt.xlim(0, 18)

plt.ylabel('Explained Variance')

plt.xlabel('Principal Components')

pca_7 = PCA(n_components = 7)

X_pca = pca_7.fit_transform(X_std)

print('Original number of features:', X.shape[1])

print('Reduced number of features:', X_pca.shape[1])

pca_df = pd.DataFrame(data = X_pca)

pca_df.head()

sns.pairplot(pca_df, diag_kind = 'kde')

X_train, X_test, y_train, y_test = train_test_split(X_std, y, test_size = 0.3, random_state = 10)

rtr, ctr = X_train.shape

print('The training set comprises of', rtr, 'rows and', ctr, 'columns.')

rt, ct = X_test.shape

print('The test set comprises of', rt, 'rows and', ct, 'columns.')

X_tr, X_te, y_tr, y_te = train_test_split(X_pca, y, test_size = 0.3, random_state =10)

rtr_pca, ctr_pca = X_tr.shape

print('The PCA training set comprises of',rtr_pca, 'rows and', ctr_pca, 'columns.')

rt_pca, ct_pca = X_te.shape

print('The PCA test set comprises of', rt_pca, 'rows and', ct_pca, 'columns.')

svc_model = SVC(kernel = 'linear', gamma ='scale', C = 1)

print('SVC Model of dataset with PCA')

# fitting the model

svc_model.fit(X_tr, y_tr)

# predict the response

y_predictSVC_pca = svc_model.predict(X_te)

modeltrSVC_pca_score = svc_model.score(X_tr, y_tr)

print('\nAccuracy Score of Training Data:', modeltrSVC_pca_score)

modelSVC_pca_score = accuracy_score(y_te,y_predictSVC_pca)

print('\nAccuracy Score of Test Data:', modelSVC_pca_score)

cfm_SVC_pca = confusion_matrix(y_te, y_predictSVC_pca)

print('\nClassification Report of SVC Model:\n ', classification_report(y_te, y_predictSVC_pca))

print('\nMean Absolute Error of SVC:\n', mean_absolute_error(y_te, y_predictSVC_pca))

print('\nConfusion Matrix of SVC:\n', cfm_SVC_pca)

#visualization of confusion matrix in theform of a heatmap

plt.figure(figsize = (8, 6))

sns.heatmap(cfm_SVC_pca, annot = True, cmap = 'YlGnBu', fmt = 'd')

plt.xlabel('Actual Classes', fontsize = 15)

plt.ylabel('Predicted Classes', fontsize =15)

plt.title('Confusion Matrix HeatMap of SVCwith PCA Model', fontsize = 15)

precision_SVC_pca, recall_SVC_pca, f1_score_SVC_pca, support = precision_recall_fscore_support(y_te, y_predictSVC_pca, average= 'macro')

print('Precision Score :', '%0.2f' % precision_SVC_pca)

print('Recall Score :', '%0.2f' % recall_SVC_pca)

print('F1-Score :', '%0.2f' % f1_score_SVC_pca)

print('Accuracy Score :','%0.2f' % modelSVC_pca_score)

print('SVC Model of dataset without PCA')

# fitting the model

svc_model.fit(X_train, y_train)

# predict the response

y_predictSVC = svc_model.predict(X_test)

modeltrSVC_score = svc_model.score(X_train, y_train)

print('\nAccuracy Score of Training Data:', modeltrSVC_score)

cfm_SVC = confusion_matrix(y_test, y_predictSVC)

# evaluate accuracy

modelSVC_score = accuracy_score(y_test, y_predictSVC)

print('\nAccuracy Score of Test Data:', modelSVC_score)

print('\nClassification Report of SVC Model:\n ', classification_report(y_test, y_predictSVC))

print('\nMean Absolute Error of SVC:\n', mean_absolute_error(y_test, y_predictSVC))

print('\nConfusion Matrix of SVC:\n', cfm_SVC)

#visualization of confusion matrix in theform of a heatmap

plt.figure(figsize = (8, 6))

sns.heatmap(cfm_SVC, annot = True, cmap ='YlGnBu', fmt = 'd')

plt.xlabel('Actual Classes', fontsize = 15)

plt.ylabel('Predicted Classes', fontsize =15)

plt.title('Confusion Matrix HeatMap of SVCModel', fontsize = 15)

precision_SVC, recall_SVC, f1_score_SVC, support = precision_recall_fscore_support(y_test, y_predictSVC, average = 'macro')

print('Precision Score :', '%0.2f' % precision_SVC)

print('Recall Score :', '%0.2f' % recall_SVC)

print('F1-Score :', '%0.2f' % f1_score_SVC)

print('Accuracy Score :','%0.2f' % modelSVC_score)

mdllists = []

mdllists.append(['Support Vector Classifier with PCA', modeltrSVC_pca_score * 100, modelSVC_pca_score * 100, recall_SVC_pca *100, precision_SVC_pca * 100])

mdllists.append(['Support Vector Classifier without PCA', modeltrSVC_score * 100, modelSVC_score * 100, recall_SVC * 100, precision_SVC * 100])

mdl_df = pd.DataFrame(mdllists, columns =['Model', 'Accuracy Score of Training Data', 'Accuracy Score of Test Data', 'RecallScore', 'Precision Score'])

mdl_df

param_grid_pca = [{'kernel': ['rbf'], 'C':[0.01, 0.05, 0.5, 1]},

                  {'kernel': ['linear'],'C': [0.01, 0.05, 0.5, 1]}]

# Make grid search classifier

clf_grid_pca = GridSearchCV(SVC(), param_grid_pca, verbose = 1)

# Train the classifier

clf_grid_pca.fit(X_tr, y_tr)

print('\n\nBest Parameters:\n', clf_grid_pca.best_params_)

print('\n\nBest Estimators:\n', clf_grid_pca.best_estimator_)

svc_cv_pca_model = SVC(kernel = 'rbf', gamma = 'scale', C = 1)

# fitting the model

svc_cv_pca_model.fit(X_tr, y_tr)

# predict the response

y_predictSVC_cv_pca = svc_cv_pca_model.predict(X_te)

modeltrSVC_cv_pca_score = svc_cv_pca_model.score(X_tr, y_tr)

print('\nAccuracy Score of Training Data:', modeltrSVC_cv_pca_score)

modelSVC_cv_pca_score = accuracy_score(y_te, y_predictSVC_cv_pca)

print('\nAccuracy Score of Test Data:', modelSVC_cv_pca_score)

cfm_SVC_cv_pca = confusion_matrix(y_te, y_predictSVC_cv_pca)

print('\nClassification Report of SVC Model:\n ', classification_report(y_te, y_predictSVC_cv_pca))

print('\nMean Absolute Error of SVC:\n', mean_absolute_error(y_te, y_predictSVC_cv_pca))

print('\nConfusion Matrix of SVC:\n', cfm_SVC_cv_pca)

#visualization of confusion matrix in theform of a heatmap

plt.figure(figsize = (8, 6))

sns.heatmap(cfm_SVC_cv_pca, annot = True,

cmap = 'YlGnBu', fmt = 'd')

plt.xlabel('Actual Classes', fontsize = 15)

plt.ylabel('Predicted Classes', fontsize =15)

plt.title('Confusion Matrix HeatMap of SVCwith PCA Model', fontsize = 15)

precision_SVC_cv_pca, recall_SVC_cv_pca, f1_score_SVC_cv_pca, support = precision_recall_fscore_support(y_te, y_predictSVC_cv_pca, average = 'macro')

print('Precision Score :', '%0.2f' % precision_SVC_cv_pca)

print('Recall Score :', '%0.2f' % recall_SVC_cv_pca)

print('F1-Score :', '%0.2f' % f1_score_SVC_cv_pca)

print('Accuracy Score :','%0.2f' % modelSVC_cv_pca_score)

param_grid = [{'kernel': ['rbf'], 'C':[0.01, 0.05, 0.5, 1]},

                  {'kernel': ['linear'],'C': [0.01, 0.05, 0.5, 1]}]

# Make grid search classifier

clf_grid = GridSearchCV(SVC(), param_grid,verbose = 1)

# Train the classifier

clf_grid.fit(X_train, y_train)

print('\n\nBest Parameters:\n', clf_grid.best_params_)

print('\n\nBest Estimators:\n', clf_grid.best_estimator_)

svc_cv_model = SVC(kernel = 'rbf', gamma ='scale', C = 1)

# fitting the model

svc_cv_model.fit(X_train, y_train)

# predict the response

y_predictSVC_cv = svc_cv_model.predict(X_test)

modeltrSVC_cv_score = svc_cv_model.score(X_train, y_train)

print('Accuracy Score of Training Data: ',modeltrSVC_cv_score)

cfm_SVC_cv = confusion_matrix(y_test, y_predictSVC_cv)

# evaluate accuracy

modelSVC_score_cv = accuracy_score(y_test,y_predictSVC_cv)

print('\nAccuracy Score of Test Data:', modelSVC_score_cv)

print('\nClassification Report of SVC Linear Model:\n ', classification_report(y_test, y_predictSVC_cv))

print('\nMean Absolute Error of SVC Linear:\n', mean_absolute_error(y_test, y_predictSVC_cv))

print('\nConfusion Matrix of SVC Linear:\n', cfm_SVC_cv)

​

#visualization of confusion matrix in theform of a heatmap

plt.figure(figsize = (8, 6))

sns.heatmap(cfm_SVC_cv, annot = True, cmap= 'YlGnBu', fmt = 'd')

plt.xlabel('Actual Classes', fontsize = 15)

plt.ylabel('Predicted Classes', fontsize =15)

plt.title('Confusion Matrix HeatMap of SVCGrid Search Model', fontsize = 15)

precision_SVC_cv, recall_SVC_cv, f1_score_SVC_cv, support = precision_recall_fscore_support(y_test, y_predictSVC_cv, average = 'macro')

print('Precision Score :', '%0.2f' % precision_SVC_cv)

print('Recall Score :', '%0.2f' % recall_SVC_cv)

print('F1-Score :', '%0.2f' % f1_score_SVC_cv)

print('Accuracy Score :','%0.2f' % modelSVC_score_cv)

modellsts = []

​

modellsts.append(['Support Vector Classifier with PCA using Grid Search', modeltrSVC_cv_pca_score * 100, modelSVC_cv_pca_score * 100, recall_SVC_cv_pca * 100, precision_SVC_cv_pca * 100])

modellsts.append(['Support Vector Classifier using Grid Search', modeltrSVC_cv_score * 100, modelSVC_score_cv * 100, recall_SVC_cv * 100, precision_SVC_cv * 100])

​

md_df = pd.DataFrame(modellsts, columns = ['Model', 'Accuracy Score of Training Data', 'Accuracy Score of Test Data', 'Recall Score', 'Precision Score'])

md_df

modellists = []

modellists.append(['Support Vector Classifier with PCA', modeltrSVC_pca_score * 100, modelSVC_pca_score * 100, recall_SVC_pca * 100, precision_SVC_pca * 100])

modellists.append(['Support Vector Classifier with PCA using Grid Search', modeltrSVC_cv_pca_score * 100, modelSVC_cv_pca_score * 100, recall_SVC_cv_pca * 100, precision_SVC_cv_pca * 100])

modellists.append(['Support Vector Classifier using Grid Search', modeltrSVC_cv_score * 100, modelSVC_score_cv * 100, recall_SVC_cv * 100, precision_SVC_cv * 100])

modellists.append(['Support Vector Classifier without PCA', modeltrSVC_score * 100, modelSVC_score * 100, recall_SVC * 100, precision_SVC * 100])

model_df = pd.DataFrame(modellists, columns = ['Model', 'Accuracy Score of Training Data', 'Accuracy Score of Test Data', 'Recall Score', 'Precision Score'])

model_df

​

plt.figure(figsize = (20, 5))

sns.barplot(x = model_df['Model'], y = model_df['Accuracy Score of Test Data'], data = model_df)

plt.xlabel('Model', fontsize = 15)

plt.ylabel('Accuracy Score', fontsize = 15)

plt.title('Comparison of Classification Models', fontsize = 15)

​

​